using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using FiltronASP.Logger;

namespace FiltronASP.Models.DAO
{
    /// <summary>
    /// Klasa dla operacji bazodanowych specyficznych dla tabeli <code>menu_items</code>.
    /// </summary>
    public class MenuItemDAO : Abstracts.AbstractGenericDAO<MenuItem, System.Nullable<int>>,
        Interfaces.IMenuItemDAO
    {
        /// <summary>
        /// Metoda zwracajaca nazwe parametru bedacego kluczem glownym tabeli.
        /// </summary>
        /// <returns>nazwa klucza glownego</returns>
        protected override string GetKeyProperty()
        {
            return "item_id";
        }

        /// <summary>
        /// Pobieranie listy obiektow na podstawie menu.
        /// </summary>
        /// <param name="menuId">menu</param>
        /// <returns>lista rekordow o zadanym menu</returns>
        public IQueryable<MenuItem> FindByMenuId(int menuId)
        {
            if (menuId.Equals(0))
            {
                return null;
            }   //if
            try
            {
                IQueryable<MenuItem> menuItems = this._cmsEntitiesDataContext.MenuItems.Where(
                    menu => menu.menu_id.Equals(menuId)
                        ).OrderBy(menu => menu.item_ordering);
                if (!(menuItems.Any()))
                {
                    return null;
                }   //if
                return menuItems;
            }   //try
            catch (Exception ex)
            {
                MyLogger.Log(ex);
            }   //catch
            return null;
        }

        /// <summary>
        /// Pobieranie listy obiektow na podstawie menu i glebokosci.
        /// </summary>
        /// <param name="menuId">menu</param>
        /// <param name="depth">glebokosc</param>
        /// <returns>lista rekordow o zadanym menu</returns>
        public IQueryable<MenuItem> FindByMenuIdAndDepth(int menuId, int depth)
        {
            if (menuId.Equals(0))
            {
                return null;
            }   //if
            try
            {
                IQueryable<MenuItem> menuItems = this._cmsEntitiesDataContext.MenuItems.Where(
                    menu => menu.menu_id.Equals(menuId) && menu.item_depth.Equals(depth)
                        ).OrderBy(menu => menu.item_ordering);
                if (!(menuItems.Any()))
                {
                    return null;
                }   //if
                return menuItems;
            }   //try
            catch (Exception ex)
            {
                MyLogger.Log(ex);
            }   //catch
            return null;
        }

        /// <summary>
        /// Pobieranie listy obiektow na podstawie rodzica.
        /// </summary>
        /// <param name="parentId">rodzic</param>
        /// <returns>lista rekordow o zadanym rodzicu</returns>
        public IQueryable<MenuItem> FindByParentId(int parentId)
        {
            if (parentId.Equals(0))
            {
                return null;
            }   //if
            try
            {
                IQueryable<MenuItem> menuItems = this._cmsEntitiesDataContext.MenuItems.Where(
                    pare => pare.parent_item_id.Equals(parentId)
                        ).OrderBy(menu => menu.item_ordering);
                if (!(menuItems.Any()))
                {
                    return null;
                }   //if
                return menuItems;
            }   //try
            catch (Exception ex)
            {
                MyLogger.Log(ex);
            }   //catch
            return null;
        }

        /// <summary>
        /// Pobieranie listy obiektow na podstawie strony.
        /// </summary>
        /// <param name="pageId">strona</param>
        /// <returns>lista rekordow o zadanym rodzicu</returns>
        public IQueryable<MenuItem> FindByPageId(int pageId)
        {
            if (pageId.Equals(0))
            {
                return null;
            }   //if
            try
            {
                IQueryable<MenuItem> menuItems = this._cmsEntitiesDataContext.MenuItems.Where(
                    page => page.page_id.Equals(pageId)
                        );
                if (!(menuItems.Any()))
                {
                    return null;
                }   //if
                return menuItems;
            }   //try
            catch (Exception ex)
            {
                MyLogger.Log(ex);
            }   //catch
            return null;
        }

        /// <summary>
        /// Pobieranie listy obiektow na podstawie języka.
        /// </summary>
        /// <param name="languageId">język</param>
        /// <returns>lista rekordow o zadanym języku</returns>
        public IQueryable<MenuItem> FindByLanguageId(int languageId)
        {
            if (languageId.Equals(0))
            {
                return null;
            }   //if
            try
            {

                IQueryable<MenuItem> menuItems = this._cmsEntitiesDataContext.MenuItems.Where(
                    lang => (this._cmsEntitiesDataContext.Menus.Where(
                        mela => mela.language_id.Equals(languageId)
                        ).Select(ml => ml.menu_id).Contains(lang.menu_id.Value)
                        )
                        );
                if (!(menuItems.Any()))
                {
                    return null;
                }   //if
                return menuItems;
            }   //try
            catch (Exception ex)
            {
                MyLogger.Log(ex);
            }   //catch
            return null;
        }

        /// <summary>
        /// Pobieranie listy obiektow na podstawie języka, nazwy menu i informacji o publikacji.
        /// </summary>
        /// <param name="languageId">język</param>
        /// <param name="menuName">nazwa menu</param>
        /// <param name="itemPublished">opublikowana</param>
        /// <returns>lista rekordow o zadanym języku, nazwie menu i informacji o publikacji</returns>
        public IQueryable<MenuItem> FindByLanguageIdAndMenuNameAndItemPublished(int languageId, String MenuName, bool itemPublished)
        {
            if (languageId.Equals(0) || String.IsNullOrEmpty(MenuName))
            {
                return null;
            }   //if
            try
            {

                IQueryable<MenuItem> menuItems = this._cmsEntitiesDataContext.MenuItems.Where(
                    lang => (this._cmsEntitiesDataContext.Menus.Where(
                        mela => mela.language_id.Equals(languageId) && mela.menu_name.Equals(MenuName)
                        ).Select(ml => ml.menu_id).Contains(lang.menu_id.Value)
                        ) && lang.item_published.Equals(itemPublished)
                        ).OrderBy(lang => lang.item_ordering);
                if (!(menuItems.Any()))
                {
                    return null;
                }   //if
                return menuItems;
            }   //try
            catch (Exception ex)
            {
                MyLogger.Log(ex);
            }   //catch
            return null;
        }

        /// <summary>
        /// Pobieranie listy obiektow na podstawie języka, nazwy menu, linku i informacji o publikacji.
        /// </summary>
        /// <param name="languageId">język</param>
        /// <param name="menuName">nazwa menu</param>
        /// <param name="itemLink">link</param>
        /// <param name="itemPublished">opublikowana</param>
        /// <returns>lista rekordow o zadanym języku, nazwie menu i informacji o publikacji</returns>
        public IQueryable<MenuItem> FindByLanguageIdAndMenuNameAndItemLinkAndItemPublished(int languageId, String MenuName, String itemLink, bool itemPublished)
        {
            if (languageId.Equals(0) || String.IsNullOrEmpty(MenuName) || String.IsNullOrEmpty(itemLink))
            {
                return null;
            }   //if
            try
            {

                IQueryable<MenuItem> menuItems = this._cmsEntitiesDataContext.MenuItems.Where(
                    lang => (this._cmsEntitiesDataContext.Menus.Where(
                        mela => mela.language_id.Equals(languageId) && mela.menu_name.Equals(MenuName)
                        ).Select(ml => ml.menu_id).Equals(lang.menu_id)
                        ) && lang.item_published.Equals(itemPublished) && lang.item_link.Equals(itemLink)
                        );
                if (!(menuItems.Any()))
                {
                    return null;
                }   //if
                return menuItems;
            }   //try
            catch (Exception ex)
            {
                MyLogger.Log(ex);
            }   //catch
            return null;
        }

        /// <summary>
        /// Pobieranie listy obiektow na podstawie języka, nazwy menu, linku i aliasu.
        /// </summary>
        /// <param name="languageId">język</param>
        /// <param name="menuName">nazwa menu</param>
        /// <param name="itemLink">link</param>
        /// <param name="itemAlias">alias</param>
        /// <returns>lista rekordow o zadanym języku, nazwie menu i informacji o publikacji</returns>
        public IQueryable<MenuItem> FindByLanguageIdAndMenuNameAndItemLinkAndItemPublished(int languageId, String MenuName, String itemLink, String itemAlias)
        {
            if (languageId.Equals(0) || String.IsNullOrEmpty(MenuName) || String.IsNullOrEmpty(itemLink) || String.IsNullOrEmpty(itemAlias))
            {
                return null;
            }   //if
            try
            {

                IQueryable<MenuItem> menuItems = this._cmsEntitiesDataContext.MenuItems.Where(
                    lang => (this._cmsEntitiesDataContext.Menus.Where(
                        mela => mela.language_id.Equals(languageId) && mela.menu_name.Equals(MenuName)
                        ).Select(ml => ml.menu_id).Equals(lang.menu_id)
                        ) && lang.item_alias.Equals(itemAlias) && lang.item_link.Equals(itemLink)
                        );
                if (!(menuItems.Any()))
                {
                    return null;
                }   //if
                return menuItems;
            }   //try
            catch (Exception ex)
            {
                MyLogger.Log(ex);
            }   //catch
            return null;
        }

        /// <summary>
        /// Pobieranie listy obiektow na podstawie menu, o item ordering> od zadanego.
        /// </summary>
        /// <param name="menuId">menu</param>
        /// <param name="parentMenuItemId">nadrzedna pozycja menu (nullable)</param>
        /// <param name="itemOrdering">porzadek</param>
        /// <returns>lista rekordow o zadanym menu, pozycji nadrzednej i porzadku</returns>
        public IQueryable<MenuItem> FindByMenuIdAndParentItemIdAndItemOrderingHigher(int menuId, int? parentMenuItemId, int itemOrdering)
        {
            if (menuId.Equals(0) || itemOrdering.Equals(0))
            {
                return null;
            }   //if
            try
            {
                IQueryable<MenuItem> menuItems;
                if (parentMenuItemId == null)
                {
                    menuItems = this._cmsEntitiesDataContext.MenuItems.Where(
                        meit => meit.menu_id.Equals(menuId) && (meit.item_ordering > itemOrdering)
                            ).OrderBy(meit => meit.item_ordering);
                }
                else
                {
                    menuItems = this._cmsEntitiesDataContext.MenuItems.Where(
                        meit => meit.menu_id.Equals(menuId) && meit.parent_item_id.Equals(parentMenuItemId) && (meit.item_ordering > itemOrdering)
                            ).OrderBy(meit => meit.item_ordering);
                }
                if (!(menuItems.Any()))
                {
                    return null;
                }   //if
                return menuItems;
            }   //try
            catch (Exception ex)
            {
                MyLogger.Log(ex);
            }   //catch
            return null;
        }

        /// <summary>
        /// Pobieranie listy obiektow na podstawie menu, o item ordering< od zadanego.
        /// </summary>
        /// <param name="menuId">menu</param>
        /// <param name="parentMenuItemId">nadrzedna pozycja menu (nullable)</param>
        /// <param name="itemOrdering">porzadek</param>
        /// <returns>lista rekordow o zadanym menu, pozycji nadrzednej i porzadku</returns>
        public IQueryable<MenuItem> FindByMenuIdAndParentItemIdAndItemOrderingLower(int menuId, int? parentMenuItemId, int itemOrdering)
        {
            if (menuId.Equals(0) || itemOrdering.Equals(0))
            {
                return null;
            }   //if
            try
            {
                IQueryable<MenuItem> menuItems;
                if (parentMenuItemId == null)
                {
                    menuItems = this._cmsEntitiesDataContext.MenuItems.Where(
                        meit => meit.menu_id.Equals(menuId) && (meit.item_ordering < itemOrdering)
                            ).OrderByDescending(meit => meit.item_ordering);
                }
                else
                {
                    menuItems = this._cmsEntitiesDataContext.MenuItems.Where(
                        meit => meit.menu_id.Equals(menuId) && meit.parent_item_id.Equals(parentMenuItemId) && (meit.item_ordering < itemOrdering)
                            ).OrderByDescending(meit => meit.item_ordering);
                }
                if (!(menuItems.Any()))
                {
                    return null;
                }   //if
                return menuItems;
            }   //try
            catch (Exception ex)
            {
                MyLogger.Log(ex);
            }   //catch
            return null;
        }

        /// <summary>
        /// Pobieranie obiektu na podstawie menu i o item ordering> od zadanego.
        /// </summary>
        /// <param name="menuId">menu</param>
        /// <param name="parentMenuItemId">nadrzedna pozycja menu (nullable)</param>
        /// <param name="itemOrdering">porzadek</param>
        /// <returns>lista rekordow o zadanym menu, pozycji nadrzednej i porzadku</returns>
        public MenuItem FindNeighbourByMenuIdAndParentItemIdAndItemOrderingHigher(int menuId, int? parentMenuItemId, int itemOrdering)
        {
            if (menuId.Equals(0) || itemOrdering.Equals(0))
            {
                return null;
            }   //if
            try
            {

                IQueryable<MenuItem> menuItems;
                if (parentMenuItemId == null)
                {
                    menuItems = this._cmsEntitiesDataContext.MenuItems.Where(
                        meit => meit.menu_id.Equals(menuId) && (meit.item_ordering > itemOrdering)
                            ).OrderBy(meit => meit.item_ordering);
                }
                else
                {
                    menuItems = this._cmsEntitiesDataContext.MenuItems.Where(
                        meit => meit.menu_id.Equals(menuId) && meit.parent_item_id.Equals(parentMenuItemId) && (meit.item_ordering > itemOrdering)
                            ).OrderBy(meit => meit.item_ordering);
                }
                if (!(menuItems.Any()))
                {
                    return null;
                }   //if
                return menuItems.FirstOrDefault();
            }   //try
            catch (Exception ex)
            {
                MyLogger.Log(ex);
            }   //catch
            return null;
        }

        /// <summary>
        /// Pobieranie obiektu na podstawie menu i o item ordering< od zadanego.
        /// </summary>
        /// <param name="menuId">menu</param>
        /// <param name="parentMenuItemId">nadrzedna pozycja menu (nullable)</param>
        /// <param name="itemOrdering">porzadek</param>
        /// <returns>lista rekordow o zadanym menu, pozycji nadrzednej i porzadku</returns>
        public MenuItem FindNeighbourByMenuIdAndParentItemIdAndItemOrderingLower(int menuId, int? parentMenuItemId, int itemOrdering)
        {
            if (menuId.Equals(0) || itemOrdering.Equals(0))
            {
                return null;
            }   //if
            try
            {
                IQueryable<MenuItem> menuItems;
                if (parentMenuItemId == null)
                {
                    menuItems = this._cmsEntitiesDataContext.MenuItems.Where(
                        meit => meit.menu_id.Equals(menuId) && (meit.item_ordering < itemOrdering)
                            ).OrderByDescending(meit => meit.item_ordering);
                }
                else
                {
                    menuItems = this._cmsEntitiesDataContext.MenuItems.Where(
                        meit => meit.menu_id.Equals(menuId) && meit.parent_item_id.Equals(parentMenuItemId) && (meit.item_ordering < itemOrdering)
                            ).OrderByDescending(meit => meit.item_ordering);
                }
                if (!(menuItems.Any()))
                {
                    return null;
                }   //if
                return menuItems.FirstOrDefault();
            }   //try
            catch (Exception ex)
            {
                MyLogger.Log(ex);
            }   //catch
            return null;
        }

        /// <summary>
        /// Metoda do zamiany porzadku pozycji menu.
        /// </summary>
        /// <param name="firstMenuItemId">pierwsza pozycja menu</param>
        /// <param name="secondMenuItemId">druga pozycja menu</param>
        /// <returns>true w przypadku powodzenia, false wpp</returns>
        public bool SwitchItemOrder(int firstMenuItemId, int secondMenuItemId)
        {
            MenuItem firstMenuItem = this.FindByPK(firstMenuItemId);
            if (firstMenuItem == null)
            {
                return false;
            }
            MenuItem secondMenuItem = this.FindByPK(secondMenuItemId);
            if (secondMenuItem == null)
            {
                return false;
            }
            int tempOrderingValue = firstMenuItem.item_ordering;
            firstMenuItem.item_ordering = secondMenuItem.item_ordering;
            if (!this.SubmitChanges())
            {
                Logger.MyLogger.Log("MenuItemDAO warning: SwitchItemOrder method, unable to commit first change...");
                return false;
            }   //if
            secondMenuItem.item_ordering = tempOrderingValue;
            if (!this.SubmitChanges())
            {
                Logger.MyLogger.Log("MenuItemDAO warning: SwitchItemOrder method, unable to commit second change...");
                return false;
            }   //if
            return true;

        }


        /// <summary>
        /// Metoda do zamiany porzadku pozycji menu (lista).
        /// </summary>
        /// <param name="menuItems">pozycje menu nad wybrana</param>
        /// <param name="secondMenuItemId">pozycja menu</param>
        /// <returns>true w przypadku powodzenia, false wpp</returns>
        public bool SwitchItemsOrder(IQueryable<MenuItem> menuItems, int menuItemToUpId)
        {
            MenuItem menuItemToUp = this.FindByPK(menuItemToUpId);
            if (menuItemToUp == null)
            {
                return false;
            }
            if (!(menuItems.Any()))
            {
                return false;
            }   //if
            int i = 0;
            int tempOrderingValue1 = 0;
            int tempOrderingValue2 = 0;
            foreach (MenuItem menuItem in menuItems)
            {
                i++;
                if (i == 1)
                {
                    tempOrderingValue1 = menuItemToUp.item_ordering;
                }
                else
                {
                    tempOrderingValue1 = tempOrderingValue2;
                }
                tempOrderingValue2 = menuItem.item_ordering;
                menuItem.item_ordering = tempOrderingValue1;
                if (!this.SubmitChanges())
                {
                    Logger.MyLogger.Log("MenuItemDAO warning: SwitchItemsOrderUp method, unable to commit changes...");
                    return false;
                }   //if
            }
            menuItemToUp.item_ordering = tempOrderingValue2;
            if (!this.SubmitChanges())
            {
                Logger.MyLogger.Log("MenuItemDAO warning: SwitchItemsOrderUp method, unable to commit changes 2...");
                return false;
            }   //if
            return true;

        }

        /// <summary>
        /// Pobieranie maksymalnego numeru porządkowego elementu dla danego menu.
        /// </summary>
        /// <param name="menuId">menu</param>
        /// <returns>maksymalny numer porządkowy elementu dla danego menu.</returns>
        public int SelectMaxItemOrdering(int menuId)
        {
            if (menuId.Equals(0))
            {
                return -1;
            }   //if
            try
            {

                int max = this._cmsEntitiesDataContext.MenuItems.Where(
                    menu => menu.menu_id.Equals(menuId)
                        ).Max(ma => ma.item_ordering);
                return max;
            }   //try
            catch (Exception ex)
            {
                MyLogger.Log(ex);
            }   //catch
            return -1;
        }

        /// <summary>
        /// Zliczanie elementów dla danego aliasu, linku i menu.
        /// </summary>
        /// <param name="itemAlias">alias</param>
        /// <param name="itemLink">link</param>
        /// <param name="menuId">menu</param>
        /// <returns>Liczba elementów o zadanym aliasie, linku i menu</returns>
        public int SelectCountItems(String itemLink, String itemAlias, int menuId)
        {
            if (String.IsNullOrEmpty(itemLink) || String.IsNullOrEmpty(itemAlias) || menuId.Equals(0))
            {
                return -1;
            }   //if
            try
            {

                int count = this._cmsEntitiesDataContext.MenuItems.Where(
                    meit => meit.item_alias.Equals(itemAlias) && meit.item_link.Equals(itemLink)
                        && meit.menu_id.Equals(menuId)
                        ).Count()
                        ;
                return count;
            }   //try
            catch (Exception ex)
            {
                MyLogger.Log(ex);
            }   //catch
            return -1;
        }

        /// <summary>
        /// Metoda zwracajaca element dla danego aliasu, linku, menu z wylaczeniem wskazanego id.
        /// </summary>
        /// <param name="itemAlias">alias</param>
        /// <param name="itemLink">link</param>
        /// <param name="menuId">menu</param>
        /// <param name="itemIdToExclude">id wylaczone z wyszukiwania</param>
        /// <returns>element dla danego aliasu, linku, menu z wylaczeniem wskazanego id</returns>
        public MenuItem FindByAliasLinkMenuIdAndNotItemId(string itemLink, string itemAlias, 
            int menuId, int itemIdToExclude)
        {
            if (String.IsNullOrEmpty(itemLink)  
                 || itemIdToExclude <= 0)
            {
                return null;
            }   //if
            try
            {
                if(String.IsNullOrEmpty(itemAlias))
                {
                    return this._cmsEntitiesDataContext.MenuItems.SingleOrDefault(
                        meit => meit.item_link.Equals(itemLink)
                            && meit.menu_id.Equals(menuId)
                            && meit.item_id != itemIdToExclude
                    );
                }
                else
                {
                                        return this._cmsEntitiesDataContext.MenuItems.SingleOrDefault(
                        meit => meit.item_alias.Equals(itemAlias) 
                            && meit.item_link.Equals(itemLink)
                            && meit.menu_id.Equals(menuId)
                            && meit.item_id != itemIdToExclude
                            );
                }
            }   //try
            catch (Exception ex)
            {
                MyLogger.Log(ex);
            }   //catch
            return null;
        }

        /// <summary>
        /// Wstawianie listy obiektów na podstawie jezyka.
        /// </summary>
        /// <param name="defaultLanguageId">domyslny jezyk</param>
        /// <param name="newLanguageId">nowy jezyk</param>
        /// <returns>true jesli sie udalo, false wpp</returns>
        public bool InsertForNewLanguage(int defaultLanguageId, int newLanguageId)
        {
            if (defaultLanguageId.Equals(0) || newLanguageId.Equals(0))
            {
                return false;
            }   //if
            try
            {
                IQueryable<MenuItem> menuItems = this.FindByLanguageId(defaultLanguageId).OrderBy(meit => meit.item_depth);
                MenuDAO _menuDAO = new MenuDAO();
                PageDAO _pageDAO = new PageDAO();
                if (menuItems == null)
                {
                    return true;
                }   //if
                if (!(menuItems.Any()))
                {
                    return true;
                }   //if
                foreach (MenuItem menuItem in menuItems)
                {
                    MenuItem menuItemToInsert = new MenuItem();
                    if (menuItem.page_id != null)
                    {
                        Page oldPage = _pageDAO.FindByPK(menuItem.page_id);
                        if (oldPage == null)
                        {
                            return false;
                        }
                        Page newPage = _pageDAO.FindByLanguageAndAlliasAndLink(newLanguageId, oldPage.page_alias, oldPage.page_link);
                        if (newPage == null)
                        {
                            return false;
                        }
                        menuItemToInsert.page_id = newPage.page_id;
                    }
                    else
                    {
                        menuItemToInsert.page_id = null;
                    }
                    Menu oldMenu = _menuDAO.FindByPK(menuItem.menu_id);
                    if (oldMenu == null)
                    {
                        return false;
                    }
                    Menu newMenu = _menuDAO.FindByLanguageIdAndName(newLanguageId, oldMenu.menu_name);
                    if (newMenu == null)
                    {
                        return false;
                    }
                    menuItemToInsert.item_alias = menuItem.item_alias;
                    menuItemToInsert.item_created = DateTime.Now;
                    menuItemToInsert.item_created_by_id = menuItem.item_created_by_id;
                    menuItemToInsert.item_depth = menuItem.item_depth;
                    menuItemToInsert.item_editable = menuItem.item_editable;
                    menuItemToInsert.item_img = menuItem.item_img;
                    menuItemToInsert.item_link = menuItem.item_link;
                    menuItemToInsert.item_modified = DateTime.Now;
                    menuItemToInsert.item_modified_by_id = menuItem.item_modified_by_id;
                    menuItemToInsert.item_name = menuItem.item_name;
                    menuItemToInsert.item_ordering = menuItem.item_ordering;
                    menuItemToInsert.item_path = menuItem.item_path;
                    menuItemToInsert.item_published = menuItem.item_published;
                    menuItemToInsert.item_removable = menuItem.item_removable;
                    menuItemToInsert.item_type_id = menuItem.item_type_id;

                    menuItemToInsert.menu_id = newMenu.menu_id;
                   if (menuItem.parent_item_id == null)
                    {
                        menuItemToInsert.parent_item_id = null;
                    }
                    else
                    {
                        MenuItem oldParent = this.FindByPK(menuItem.parent_item_id);
                        if (oldParent == null)
                        {
                            return false;
                        }
                        MenuItem newParent = this.FindByAliasLinkMenuIdAndNotItemId(oldParent.item_link, 
                            oldParent.item_alias ?? "", newMenu.menu_id, oldParent.item_id);
                        if (newParent == null)
                        {
                            return false;
                        }
                        menuItemToInsert.parent_item_id = newParent.item_id;
                    }
                    this.Add(menuItemToInsert);
                }

            }   //try
            catch (Exception ex)
            {
                MyLogger.Log(ex);
            }   //catch
            return true;
        }

        /// <summary>
        /// Pobieranie najwyższego id dla elementu menu.
        /// </summary>
        /// <returns>najwyższe id dla elementu menu</returns>
        public int? SelectMaxMenuItemId()
        {
            try
            {
                return this._cmsEntitiesDataContext.MenuItems.Max(ma => ma.item_id);
            }   //try
            catch (Exception ex)
            {
                MyLogger.Log(ex);
            }   //catch
            return 0;
        }

        /// <summary>
        /// Usuwanie obiektow po jezyku.
        /// </summary>
        /// <param name="languageId">jezyk</param>
        /// <returns>true dla sukcesu, false w przeciwnym razie</returns>
        public bool DeleteByLanguage(int languageId)
        {
            if (languageId.Equals(0))
            {
                return false;
            }   //if
            try
            {
                IQueryable<MenuItem> menuItems = this.FindByLanguageId(languageId);
                if (menuItems == null)
                {
                    return true;
                }   //if
                if (!(menuItems.Any()))
                {
                    return true;
                }   //if
                foreach (MenuItem menuItem in menuItems)
                {
                    this._cmsEntitiesDataContext.MenuItems.DeleteOnSubmit(menuItem);
                }
                try
                {
                    _cmsEntitiesDataContext.SubmitChanges();

                }
                catch (Exception ex)
                {
                    MyLogger.Log(ex);
                }   //catch
                return true;
            }   //try
            catch (Exception ex)
            {
                MyLogger.Log(ex);
            }   //catch
            return false;
        }

        /// <summary>
        /// Aktualizacja linkow.
        /// </summary>
        /// <param name="defaultLanguageId">domyslny jezyk</param>
        /// <param name="newLanguageId">nowy jezyk</param>
        /// <returns>true jesli sie udalo, false wpp</returns>
        public bool UpdateLinksForNewLanguage(int newLanguageId)
        {
            if (newLanguageId <= 0)
            {
                return false;
            }   //if
            try
            {
                IQueryable<MenuItem> menuItems = this.FindByLanguageId(newLanguageId);
                if (menuItems == null)
                {
                    return true;
                }   //if
                if (!(menuItems.Any()))
                {
                    return true;
                }   //if
                foreach (MenuItem menuItem in menuItems)
                {
                    if (menuItem.Page != null)
                    {
                        menuItem.item_link = this.GenerateMenuItemLink(menuItem.Page);
                        if (!this.SubmitChanges())
                        {
                            throw new Exception(String.Format("MenuItemDAO exception: unable to update menu item link, menuItemId: {0}...", menuItem.item_id));
                        }   //if
                    }   //if
                }   //for
            }   //try
            catch (Exception ex)
            {
                MyLogger.Log(ex);
            }   //catch
            return true;
        }

        /// <summary>
        /// Metoda do generowania linka dla pozycji w menu.
        /// </summary>
        /// <param name="page">strona</param>
        /// <returns>link</returns>
        private string GenerateMenuItemLink(Page page)
        {
            if (page == null)
            {
                throw new Exception("MenuItemDAO exception: GenerateMenuItemAlias method, page object null...");
            }   //if null
            return page.page_link;
        }

    }
}
